package com.adong.juc;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * stream简单回顾
 */
public class StreamDemo {
    public static void main(String[] args) {

        // 集合讲的是数据,流讲的是计算,用于操作数据源(集合,数组等) 所生成的元素序列
        // 特点:
        // 1.Stream自己不会存储元素
        // 2.Stream不会改变源对象,相反他们会返回一个持有结果的新的Stream
        // 3.Stream操作是延迟执行的,这意味着他们会等到结果的时候才执行

        // 创建一个Stream : 一个数据源(数组,集合)
        // 中间操作 : 一个中间操作,处理数据源数据
        // 终止操作 : 一个终结操作,执行中间操作链,产生结果

        User user1 = new User(11, "a", 23);
        User user2 = new User(12, "b", 24);
        User user3 = new User(13, "c", 25);
        User user4 = new User(14, "d", 26);
        User user5 = new User(15, "e", 27);

        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);

        // 按照数据找出偶数id,年龄大于24,用户名转为大写,用户名字母倒序,只输出一个用户
        // p 表示list中一个一个的user
        List<User> collect = list.stream().filter(p -> {
            return p.getId() % 2 == 0; //找出偶数id
        }).filter(p -> {
            return p.getAge() > 24; //年龄大于24
        }).map(t -> {
            t.setUserName(t.getUserName().toUpperCase());
            return t;
        }).sorted((t1, t2) -> {
            return t2.getUserName().compareTo(t1.getUserName()); //用户名字母倒序
        }).collect(Collectors.toList());//只输出一个用户名字

        System.out.println(collect);

        //list.forEach(System.out::println);


    }

    private static void Test() {
        // void accept(T t); 消费型 有参数 无返回值
        Consumer<String> consumer = t -> {
            System.out.println(t);
        };
        consumer.accept("abc");

        //  T get(); 供给型 无参数 有返回值
        Supplier<String> supplier = () -> {
            return UUID.randomUUID().toString();
        };
        System.out.println(supplier.get());

        // R apply(T t); 函数型 有参数 有返回值
        Function<String, Integer> function = t -> {
            return t.length();
        };
        System.out.println(function.apply("adong"));

        // boolean test(T t); 断言型 有参数 boolean返回值
        Predicate<String> predicate = t -> {
            return t.startsWith("a");
        };
        System.out.println(predicate.test("abc"));
    }

}

class User {
    private int id;
    private String userName;
    private int age;

    public User(int id, String userName, int age) {
        this.id = id;
        this.userName = userName;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}
